import axios from 'axios';
import { ElMessage } from 'element-plus';

// 创建axios实例
const api = axios.create({
  baseURL: '/api', // 基础URL
  timeout: 10000, // 请求超时时间
  headers: {
    'Content-Type': 'application/json'
  },
  withCredentials: true // 允许携带cookie
});

// 创建实名认证相关接口的axios实例（全局单例）
const verificationApi = axios.create({
  baseURL: 'http://localhost:8088',
  timeout: 10000,
  withCredentials: true
});

// 添加请求拦截器获取token
verificationApi.interceptors.request.use(
  config => {
    const token = localStorage.getItem('userToken') || sessionStorage.getItem('userToken');
    if (token) {
      config.headers['Authorization'] = `Bearer ${token}`;
    }
    return config;
  },
  error => {
    return Promise.reject(error);
  }
);

// 响应拦截器 - 与api实例保持一致的响应处理
verificationApi.interceptors.response.use(
  response => {
    // 对响应数据做点什么
    return response.data;
  },
  error => {
    // 对响应错误做点什么
    if (error.response) {
      // 服务器返回了错误状态码
      switch (error.response.status) {
        case 401:
          // 未授权，清除token并跳转到登录页
          localStorage.removeItem('userToken');
          sessionStorage.removeItem('userToken');
          window.location.href = '/login';
          break;
        case 403:
          ElMessage.error('权限不足，请联系管理员');
          break;
        case 404:
          ElMessage.error('请求的资源不存在');
          break;
        case 500:
          ElMessage.error('服务器内部错误');
          break;
        default:
          ElMessage.error(error.response.data.message || '请求失败');
      }
    } else if (error.request) {
      // 请求发出但没有收到响应
      ElMessage.error('网络错误，请检查网络连接');
    } else {
      // 设置请求时发生错误
      ElMessage.error('请求配置错误');
    }
    return Promise.reject(error);
  }
);

// 请求拦截器
api.interceptors.request.use(
  config => {
    // 在发送请求之前做些什么
    const token = localStorage.getItem('userToken') || sessionStorage.getItem('userToken');
    if (token) {
      config.headers['Authorization'] = `Bearer ${token}`;
    }
    return config;
  },
  error => {
    // 对请求错误做些什么
    return Promise.reject(error);
  }
);

// 响应拦截器
api.interceptors.response.use(
  response => {
    // 对响应数据做点什么
    return response.data;
  },
  error => {
    // 对响应错误做点什么
    if (error.response) {
      // 服务器返回了错误状态码
      switch (error.response.status) {
        case 401:
          // 未授权，清除token并跳转到登录页
          localStorage.removeItem('userToken');
          sessionStorage.removeItem('userToken');
          window.location.href = '/login';
          break;
        case 403:
          ElMessage.error('权限不足，请联系管理员');
          break;
        case 404:
          ElMessage.error('请求的资源不存在');
          break;
        case 500:
          ElMessage.error('服务器内部错误');
          break;
        default:
          ElMessage.error(error.response.data.message || '请求失败');
      }
    } else if (error.request) {
      // 请求发出但没有收到响应
      ElMessage.error('网络错误，请检查网络连接');
    } else {
      // 设置请求时发生错误
      ElMessage.error('请求配置错误');
    }
    return Promise.reject(error);
  }
);

// 用户相关API接口
export const userAPI = {
  // 创建班级 - 对应后端接口 127.0.0.1:8088/insertClass
  createClass: async (classData) => {
    try {
      // 创建FormData对象
      const formData = new FormData();
      
      // 添加普通字段
      formData.append('name', classData.className);
      formData.append('subject', classData.subject || '');
      formData.append('grade', classData.grade);
      formData.append('description', classData.description || '');
      formData.append('semester', classData.semester || '');
      
      // 添加文件（如果有）
      if (classData.file) {
        formData.append('file', classData.file);
      }

      // 调用后端创建班级接口，使用verificationApi实例
      const response = await verificationApi.post('/insertClass', formData, {
        headers: {
          'Content-Type': 'multipart/form-data'
        },
        timeout: 30000 // 文件上传需要较长超时时间
      });

      // 根据后端返回的格式处理响应（注意：verificationApi的响应拦截器已将响应处理为response.data）
      if (response && response.code === 200) {
        return {
          success: true,
          data: response.data,
          message: response.message
        };
      } else {
        return {
          success: false,
          message: response.message || '创建班级失败'
        };
      }
    } catch (error) {
      console.error('创建班级失败:', error);
      ElMessage.error('网络连接失败，请检查网络设置');
      throw error;
    }
  },
  // 获取用户信息 - 调用后端接口 127.0.0.1:8088/api/auth/me
  getProfile: async () => {
    try {
      const response = await verificationApi.get('/api/auth/me');
      return response;
    } catch (error) {
      console.error('获取用户信息失败:', error);
      throw error;
    }
  },

  // 获取学习统计
  getStats: async () => {
    try {
      const response = await api.get('/user/stats');
      return response;
    } catch (error) {
      console.error('获取学习统计失败:', error);
      throw error;
    }
  },

  // 获取班级列表
  getClassList: async () => {
    try {
      // 使用配置好的verificationApi实例调用classes接口
      const response = await verificationApi.get('/classes');
      return response;
    } catch (error) {
      console.error('获取班级列表失败:', error);
      ElMessage.error('获取班级列表失败，请检查网络连接');
      throw error;
    }
  },

  // 更新个人信息 - 对应后端接口 127.0.0.1:8088/person/updateInformation
  updateProfile: async (profileData) => {
    try {
      // 构建与后端匹配的请求参数格式
      const requestData = {
        phone: profileData.phone || '',
        nickname: profileData.nickname,
        avatar: profileData.avatar || '',
        gender: profileData.gender,
        age: profileData.age || '',
        real_name: profileData.realName || '',
        email: profileData.email
      };
      
      // 调用后端更新个人信息接口，使用verificationApi实例
      const response = await verificationApi.post('/person/updateInformation', requestData);
      
      // 根据后端返回的格式处理响应
      if (response && response.code === 200) {
        return {
          success: true,
          message: response.message
        };
      } else {
        return {
          success: false,
          message: response?.message || '更新个人信息失败'
        };
      }
    } catch (error) {
      console.error('更新个人信息失败:', error);
      throw error;
    }
  },

  // 修改密码 - 对应后端接口 127.0.0.1:8088/person/change-password
  changePassword: async (passwordData) => {
    try {
      // 构建与后端匹配的请求参数格式
      const requestData = {
        oldPassword: passwordData.oldPassword,
        newPassword: passwordData.newPassword
      };
      
      // 调用后端修改密码接口，使用verificationApi实例
      const response = await verificationApi.post('/person/change-password', requestData);
      
      // 根据后端返回的格式处理响应（注意：响应已被拦截器处理为response.data）
      if (response && response.code === 200) {
        return {
          success: true,
          message: response.message
        };
      } else {
        return {
          success: false,
          message: response?.message || '修改密码失败'
        };
      }
    } catch (error) {
      console.error('修改密码失败:', error);
      ElMessage.error('网络连接失败，请检查网络设置');
      throw error;
    }
  },

  // 上传头像 - 对应后端接口 127.0.0.1:8088/person/uploadImage
  uploadAvatar: async (file) => {
    try {
      const formData = new FormData();
      formData.append('file', file);
      // 调用后端头像上传接口，使用verificationApi实例并设置较长的超时时间
      const response = await verificationApi.post('/person/uploadImage', formData, {
        headers: {
          'Content-Type': 'multipart/form-data'
        },
        timeout: 30000 // 文件上传需要较长超时时间
      });
      
      // 根据后端返回的格式处理响应
      if (response && response.code === 200) {
        return {
          success: true,
          data: {
            avatar: response.data.url // 从响应data中获取url作为头像地址
          },
          message: response.message
        };
      } else {
        return {
          success: false,
          message: response?.message || '上传头像失败'
        };
      }
    } catch (error) {
      console.error('上传头像失败:', error);
      ElMessage.error('网络连接失败，请检查网络设置');
      throw error;
    }
  },

  // 提交实名认证 - 对应后端接口 127.0.0.1:8088/person/updateRealName
  submitVerification: async (file) => {
    try {
      // 创建FormData对象并添加文件
      const formData = new FormData();
      formData.append('file', file);

      // 调用后端实名认证接口，直接使用verificationApi实例并设置较长的超时时间
      const response = await verificationApi.post('/person/updateRealName', formData, {
        headers: {
          'Content-Type': 'multipart/form-data'
        },
        timeout: 30000 // 文件上传需要较长超时时间
      });

      // 根据后端返回的格式处理响应
      if (response.data && response.data.code === 200) {
        return {
          success: true,
          message: response.data.message
        };
      } else {
        return {
          success: false,
          message: response.data.message || '实名认证提交失败'
        };
      }
    } catch (error) {
      console.error('提交实名认证失败:', error);
      ElMessage.error('网络连接失败，请检查网络设置');
      throw error;
    }
  },

  // 获取实名认证状态 - 对应后端接口 127.0.0.1:8088/person/auth-status
  getAuthStatus: async () => {
    try {

      // 调用后端实名认证状态接口
      const response = await verificationApi.get('/person/auth-status');

      // 根据后端返回的格式处理响应
      if (response.code === 200) {
        return {
          success: true,
          data: {
            isVerified: response.data.is_verified === 1
          },
          message: response.message
        };
      } else {
        return {
          success: false,
          message: response.message || '获取实名认证状态失败'
        };
      }
    } catch (error) {
      console.error('获取实名认证状态失败:', error);
      throw error;
    }
  },

  // 获取用户真实姓名 - 对应后端接口 127.0.0.1:8088/person/real-name
  getRealName: async () => {
    try {

      // 调用后端获取真实姓名接口
      const response = await verificationApi.get('/person/real-name');

      // 根据后端返回的格式处理响应
      if (response.data && response.data.code === 200) {
        return {
          success: true,
          data: {
            realName: response.data.data.realName
          },
          message: response.data.message
        };
      } else {
        return {
          success: false,
          message: response.data.message || '获取真实姓名失败'
        };
      }
    } catch (error) {
      console.error('获取真实姓名失败:', error);
      throw error;
    }
  },
  
  // 获取班级学生列表 - 对应后端接口 127.0.0.1:8088/manageStudent/selectStudentInfo
  getStudentList: async (classCode) => {
    try {
      // 调用后端获取班级学生列表接口
      // verificationApi的响应拦截器已经返回了response.data，所以这里直接返回response
      const response = await verificationApi.get('/manageStudent/selectStudentInfo', {
        params: {
          classCode: classCode
        }
      });
      
      // 直接返回响应（由于verificationApi的响应拦截器已经处理，这已经是response.data）
      return response;
    } catch (error) {
      console.error('获取学生列表失败:', error);
      throw error;
    }
  },
  
  // 移除班级学生 - 对应后端接口 127.0.0.1:8088/manageStudent/removeStudent
  removeStudent: async (classCode, studentId) => {
    try {
      // 直接使用已有的verificationApi实例（baseURL为http://localhost:8088）
      const response = await verificationApi.delete('/manageStudent/removeStudent', {
        params: {
          classCode: classCode,
          studentId: studentId
        }
      });
      
      return response.data;
    } catch (error) {
      console.error('移除学生失败:', error);
      throw error;
    }
  },
  
  // 获取待申请加入班级的学生列表 - 对应后端接口 127.0.0.1:8088/manageStudent/getPendingApplications
  getPendingApplications: async () => {
    try {
      // 调用后端获取待申请学生接口
      const response = await verificationApi.get('/manageStudent/getPendingApplications');
      
      // 直接返回完整的响应对象，包括code、message、data和timestamp
      return response;
    } catch (error) {
      console.error('获取待申请学生失败:', error);
      throw error;
    }
  },
  
  // 同意学生加入班级 - 对应后端接口 127.0.0.1:8088/manageStudent/agreeStudent
  agreeStudent: async (classCode, studentId) => {
    try {
      // 调用后端同意学生加入班级接口
      const response = await verificationApi.post('/manageStudent/agreeStudent', {
        classCode: classCode,
        studentId: studentId
      }, {
        headers: {
          'Content-Type': 'application/json'
        }
      });
      
      // 返回完整的响应对象，以便调用方可以检查code和message
      return response;
    } catch (error) {
      console.error('同意学生加入班级失败:', error);
      throw error;
    }
  },
  
  // 更新学生申请状态 - 对应后端接口 127.0.0.1:8088/manageStudent/updateApplicationStatus
  updateApplicationStatus: async (userId, status, reason = '') => {
    try {
      // 构建请求参数，包含userId和status，可选包含reason
      const requestData = {
        userId: userId,
        status: status
      };
      
      // 如果有拒绝原因，添加到请求参数中
      if (reason) {
        requestData.reason = reason;
      }
      
      // 调用后端更新学生申请状态接口
      const response = await verificationApi.post('/manageStudent/updateApplicationStatus', requestData, {
        headers: {
          'Content-Type': 'application/json'
        }
      });
      
      // 返回完整的响应对象，以便调用方可以检查code和message
      return response;
    } catch (error) {
      console.error('更新学生申请状态失败:', error);
      throw error;
    }
  },

  // 解散班级 - 对应后端接口 /class/dissolve
  dissolveClass: async (classCode) => {
    try {
      // 使用verificationApi实例调用后端解散班级接口，使用DELETE请求
      const response = await verificationApi.delete('/class/dissolve', {
        params: {
          classCode: classCode
        }
      });
      
      return response;
    } catch (error) {
      console.error('解散班级失败:', error);
      throw error;
    }
  },
  
  // 获取已批准/已拒绝的学生申请记录 - 对应后端接口 127.0.0.1:8088/manageStudent/getApprovedApplications
  getApprovedApplications: async () => {
    try {
      // 调用后端获取已批准和已拒绝的申请记录接口
      const response = await verificationApi.get('/manageStudent/getApprovedApplications');
      
      // 后端返回的数据结构是 {code: 200, message: '操作成功', data: [...], timestamp: 123456}
      // 需要保留原始结构并确保StudentClasses.vue能正确处理
      return response;
    } catch (error) {
      console.error('获取已处理申请记录失败:', error);
      throw error;
    }
  }
};

// 导出主要API和辅助API
export default api;
export { verificationApi };